package com.citywithincity.utils;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

public class ObjectUtil {
	
	/**
	 * src与dest比较，看看有哪些字段是不一样的
	 * @param src
	 * @param dest
	 * @return
	 * @throws IllegalAccessException 
	 * @throws IllegalArgumentException 
	 */
	public static Map<String, Object> compareObject(Object src,Object dest){
		
		Map<String, Object> data = new HashMap<String, Object>();
		Field[] fields = CachedClassUtil.getFields(src.getClass());
		/**
		 * 
		 */
		try{
			for (Field field : fields) {
				Object newValue = field.get(src);
				if(newValue==null)continue;
				Object oldValue = field.get(dest);
				if(newValue.equals(oldValue)){
					continue;
				}
				data.put(field.getName(), newValue);
			}
			
		}catch(Exception e){
			throw new RuntimeException(e);
		}
		
		return data;
		
	}

	public static boolean isEqual(Object src, Object dest) {
		if(src == null){
			if(dest != null){
				return false;
			}
			return true;
		}else{
			if(dest == null){
				return false;
			}
			return src.equals(dest);
		}
	}
	
	 /**
     * 判断两个对象是否相等。 这个函数用处是:
     * <ul>
     * <li>可以容忍 null
     * <li>可以容忍不同类型的 Number
     * <li>对数组，集合， Map 会深层比较
     * </ul>
     * 当然，如果你重写的 equals 方法会优先
     * 
     * @param a0
     *            比较对象1
     * @param a1
     *            比较对象2
     * @return 是否相等
     */
    public static boolean equals(Object a0, Object a1) {
        if (a0 == a1)
            return true;

        if (a0 == null && a1 == null)
            return true;

        if (a0 == null || a1 == null)
            return false;

        // 简单的判断是否等于
        if (a0.equals(a1))
            return true;

        
        //ClassUtil.isSimpleClass(type);
    
        // 如果类型就不能互相转换，那么一定是错的
        if (!a0.getClass().isAssignableFrom(a1.getClass())
            && !a1.getClass().isAssignableFrom(a0.getClass()))
            return false;

        // Map
        if (a0 instanceof Map && a1 instanceof Map) {
            Map<?, ?> m1 = (Map<?, ?>) a0;
            Map<?, ?> m2 = (Map<?, ?>) a1;
            if (m1.size() != m2.size())
                return false;
            for (Entry<?, ?> e : m1.entrySet()) {
                Object key = e.getKey();
                if (!m2.containsKey(key) || !equals(m1.get(key), m2.get(key)))
                    return false;
            }
            return true;
        }
        // 数组
        else if (a0.getClass().isArray() && a1.getClass().isArray()) {
            int len = Array.getLength(a0);
            if (len != Array.getLength(a1))
                return false;
            for (int i = 0; i < len; i++) {
                if (!equals(Array.get(a0, i), Array.get(a1, i)))
                    return false;
            }
            return true;
        }
        // 集合
        else if (a0 instanceof Collection && a1 instanceof Collection) {
            Collection<?> c0 = (Collection<?>) a0;
            Collection<?> c1 = (Collection<?>) a1;
            if (c0.size() != c1.size())
                return false;

            Iterator<?> it0 = c0.iterator();
            Iterator<?> it1 = c1.iterator();

            while (it0.hasNext()) {
                Object o0 = it0.next();
                Object o1 = it1.next();
                if (!equals(o0, o1))
                    return false;
            }

            return true;
        }

        // 一定不相等
        return false;
    }

}
